home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / xmmlrg.exe / TEST.C < prev    next >
C/C++ Source or Header  |  1991-08-02  |  9KB  |  354 lines
  1. /*
  2.  *    HITEST.C - Test Routines for HIMEM.SYS
  3.  *
  4.  *    Copyright (c) 1988, Microsoft Corporation
  5.  */
  6.  
  7. #define    LINT_ARGS
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11.  
  12. #include    "xmm.h"
  13.  
  14. int    quiet = 0;
  15.  
  16. #define    MAXHANDLES    (32*2)
  17. #define    BUFLEN        1024
  18.  
  19. struct    HandleInfo {
  20.     short        Handle;
  21.     short        Length;
  22.     short        Filler;
  23.     unsigned long    RealAddress;
  24. };
  25.  
  26. struct HandleInfo    HandleTable[MAXHANDLES];
  27.  
  28. struct XMM_Move MoveS;
  29.  
  30. short    BufferLow[BUFLEN];
  31. short    BufferExt[BUFLEN];
  32. short    BufferHi[BUFLEN];
  33.  
  34. void  main(int  argc,char  * *argv);
  35. void  TestWrap(void);
  36. void  EnableA20(void);
  37. void  DisableA20(void);
  38. void  QueryA20(void);
  39. void  Fill(int  *ptr,int  pattern,int  count);
  40. int  Cmp(int  *ptr1,int  *ptr2,int  count);
  41. void  printq(char  *arg);
  42. void  Error(char  *string,long  code);
  43. void  Exit_Test(void);
  44.  
  45. void  main(int  argc,char  * *argv)
  46. {
  47.     long        XMM_Ret;
  48.     int        Request_Amount;
  49.     int        hi;
  50.     long        Alloc_Ret;
  51.     short        TotalAllocated = 0;
  52.     short        Handles;
  53.     short        MemPerHandle;
  54.  
  55.     if ( argc > 1 && argv[1][0] == 'q' )
  56.         quiet = 1;
  57.  
  58.     if ( XMM_Installed() ) {
  59.         printf("Extended Memory Manager Found\n\n");
  60.         XMM_Ret = XMM_Version();
  61.         printf("XMM Version %4X, Internal Version %4x\n\n",
  62.             (short)XMM_Ret, (short)(XMM_Ret >> 16));
  63.     } else {
  64.         printf("No Extended Memory Manager Present\n\n");
  65.         Exit_Test();
  66.     }
  67.     Request_Amount = 0;
  68.     do { 
  69.         XMM_Ret = XMM_RequestHMA(Request_Amount);
  70.         if ( XMM_Ret == 0 )
  71.             break;
  72.         Request_Amount++;
  73.     } while ( Request_Amount );
  74.     if ( XMM_Ret == 0 ) {
  75.         printf("Got HMA with Request of %d Kb\n", Request_Amount);
  76.         if ( XMM_RequestHMA(Request_Amount) == 0 ) {
  77.             printf("Unexpected success requesting HMA again\n");
  78.         }
  79.         XMM_Ret = XMM_ReleaseHMA();
  80.         if ( XMM_Ret )
  81.             Error("Could not release HMA", XMM_Ret);
  82.         else
  83.             printq("Released HMA\n");
  84.     } else {
  85.         Error("Could not Get HMA", XMM_Ret);
  86.     }
  87.     EnableA20();
  88.     EnableA20();
  89.     DisableA20();
  90.     EnableA20();
  91.     DisableA20();
  92.     EnableA20();
  93.     DisableA20();
  94.     DisableA20();
  95.  
  96.     /* Soak up all extended memory and handles */
  97.     hi = 0;
  98.     while ( hi < MAXHANDLES ) {
  99.         long    FreeExtended;
  100.         FreeExtended = XMM_QueryLargestFree();
  101.         if ( FreeExtended < 0 ) {
  102.             if ( XMSERROR(FreeExtended) == (char)0xA0 )
  103.                 FreeExtended = 0L;
  104.             else {
  105.                 Error("Query Free Extended Failed", FreeExtended);
  106.                 break;
  107.             }
  108.         }
  109.         if ( hi < MAXHANDLES -1  && FreeExtended > 1 )
  110.             FreeExtended /= 2;
  111.         if ( !quiet )
  112.             printf("Attempt to Allocate %d Kb\n", FreeExtended);
  113.         Alloc_Ret = XMM_AllocateExtended((unsigned )FreeExtended);
  114.         if ( Alloc_Ret < 0 ) {
  115.             if ( XMSERROR(Alloc_Ret) == (char)0xA1 )
  116.                 break;
  117.             Error("Allocate Failed", Alloc_Ret);
  118.         } else {
  119.             TotalAllocated += FreeExtended;
  120.             HandleTable[hi].Handle = (short)Alloc_Ret;
  121.         }
  122.         hi++;
  123.     }
  124.     Handles = hi;
  125.     printf("%d Kb Free Found and Allocated \n", TotalAllocated);
  126.     printf("%d handle(s) allocated\n", Handles);
  127.     printq("Freeing first handle\n");
  128.     XMM_Ret = XMM_FreeExtended(HandleTable[0].Handle);
  129.     if ( XMM_Ret )
  130.         Error("Free Extended Memory Block", XMM_Ret);
  131.     printq("Reallocate first handle with 0 length\n");
  132.     Alloc_Ret = XMM_AllocateExtended(0);
  133.     if ( Alloc_Ret < 0 )
  134.         Error("Zero Length Allocate failed", Alloc_Ret);
  135.     else
  136.         HandleTable[0].Handle = (short)Alloc_Ret;
  137.     hi = 0;
  138.     while ( hi < Handles ) {
  139.         if ( HandleTable[hi].Handle == 0 )
  140.             break;
  141.         if ( !quiet )
  142.             printf("Freeing Handle #%d (%x)\n", hi,
  143.                 HandleTable[hi].Handle);
  144.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  145.         if ( XMM_Ret )
  146.             Error("Free Extended Memory Block", XMM_Ret);
  147.         hi++;
  148.     }
  149.  
  150.     if ( Handles == 0 )
  151.         Exit_Test();
  152.     MemPerHandle = TotalAllocated / Handles + 1;
  153.     if ( (long)BUFLEN < MemPerHandle * 512L )
  154.         MemPerHandle = BUFLEN/512;
  155.     if ( !quiet )
  156.         printf("Allocating in %d Kb chunks\n", MemPerHandle);
  157.     hi = 0;
  158.     while ( hi < Handles ) {
  159.         XMM_Ret = XMM_AllocateExtended(MemPerHandle);
  160.         if ( XMM_Ret < 0 ) {
  161.             if ( XMSERROR(XMM_Ret) != 0xA0 )
  162.                 Error("Allocate", XMM_Ret);
  163.             break;
  164.         }
  165.         HandleTable[hi].Handle = (short)XMM_Ret;
  166.         HandleTable[hi].Length = MemPerHandle;
  167.         XMM_Ret = XMM_LockExtended((short)XMM_Ret);
  168.         if ( XMM_Ret < 0 ) {
  169.             printf("Handle %4x: ", HandleTable[hi].Handle);
  170.             Error("Lock Failed", XMM_Ret);
  171.         }
  172.         if ( !quiet )
  173.             printf("Handle %4x: Real Address %lx\n", HandleTable[hi].Handle,XMM_Ret);
  174.         HandleTable[hi].RealAddress = XMM_Ret;
  175.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  176.         if ( XMM_Ret >= 0 ) {
  177.             printf("Unexpected success freeing locked Handle\n");
  178.             break;
  179.         } else if ( XMSERROR(XMM_Ret) != (char)0xAB ) {
  180.             Error("Freeing Locked Handle", XMM_Ret);
  181.         }
  182.         Fill(BufferExt, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  183.         MoveS.Length = MemPerHandle*1024L;
  184.         MoveS.SourceHandle = 0;
  185.         (char far *)MoveS.SourceOffset = (char far *)BufferExt;
  186.         MoveS.DestHandle = HandleTable[hi].Handle;
  187.         MoveS.DestOffset = 0L;
  188.         XMM_Ret = XMM_MoveExtended(&MoveS);
  189.         if ( XMM_Ret < 0 )
  190.             Error("Move to Extended Memory Failed", XMM_Ret);
  191.         hi++;
  192.     }
  193.     Handles = hi;        /* How many we got this time */
  194.  
  195.     if ( hi == 0 )
  196.         Exit_Test();
  197.  
  198.     while ( --hi >= 0 ) {
  199.         if ( !quiet )
  200.             printf("Checking Handle %x\n", HandleTable[hi].Handle);
  201.         Fill(BufferLow, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  202.         MoveS.Length = MemPerHandle*1024L;
  203.         MoveS.SourceHandle = HandleTable[hi].Handle;
  204.         MoveS.SourceOffset = 0L;
  205.         MoveS.DestHandle = 0;
  206.         (char far *)MoveS.DestOffset = (char far *)BufferHi;
  207.         XMM_Ret = XMM_MoveExtended(&MoveS);
  208.         if ( XMM_Ret < 0 )
  209.             Error("Move from Extended Memory Failed", XMM_Ret);
  210.         if ( Cmp(BufferLow, BufferHi, BUFLEN) )
  211.             printf("Comparison Failed, Handle %x\n",
  212.                 HandleTable[hi].Handle);
  213.         XMM_Ret = XMM_UnLockExtended(HandleTable[hi].Handle);
  214.         if ( XMM_Ret < 0 )
  215.             Error("Unlock of Extended Memory Failed", XMM_Ret);
  216.     }
  217.  
  218.     hi = 0;
  219.     while ( hi < Handles ) {
  220.         Fill(BufferLow, HandleTable[hi].Handle ^ 0xAAAA, BUFLEN);
  221.         MoveS.Length = MemPerHandle*1024L;
  222.         MoveS.SourceHandle = HandleTable[hi].Handle;
  223.         MoveS.SourceOffset = 0L;
  224.         MoveS.DestHandle = 0;
  225.         (char far *)MoveS.DestOffset = (char far *)BufferHi;
  226.         XMM_Ret = XMM_MoveExtended(&MoveS);
  227.         if ( XMM_Ret < 0 )
  228.             Error("Move from Unlocked Extended Memory Failed", XMM_Ret);
  229.         if ( Cmp(BufferLow, BufferHi, MemPerHandle*512) )
  230.             printf("Comparison Failed, Unlocked Handle %x\n",
  231.                 HandleTable[hi].Handle);
  232.  
  233.             /* Check weird cases */
  234.         MoveS.Length = 1;
  235.         XMM_Ret = XMM_MoveExtended(&MoveS);
  236.         if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  237.             Error("Move Extended with Odd Length", XMM_Ret);
  238.  
  239.         MoveS.Length = MemPerHandle*1024L + 2;
  240.         XMM_Ret = XMM_MoveExtended(&MoveS);
  241.         if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  242.             Error("Move Extended with Length too long", XMM_Ret);
  243.  
  244.         MoveS.Length = MemPerHandle*1024L -2;
  245.         MoveS.SourceOffset = 4L;
  246.         XMM_Ret = XMM_MoveExtended(&MoveS);
  247.         if ( XMM_Ret >= 0 )
  248.             Error("Move Extended Base+Length too large", XMM_Ret);
  249.  
  250.         XMM_Ret = XMM_FreeExtended(HandleTable[hi].Handle);
  251.         if ( XMM_Ret < 0 )
  252.             Error("Free of Extended Memory Failed", XMM_Ret);
  253.  
  254.         XMM_Ret = XMM_MoveExtended(&MoveS);
  255.         if ( XMSERROR(XMM_Ret) != (char)0xA3 )
  256.             Error("Move Extended from Invalid Handle", XMM_Ret);
  257.         hi++;
  258.     }
  259.  
  260.     TestWrap();
  261.  
  262.     Exit_Test();
  263. }
  264.  
  265. void  TestWrap(void)
  266. {
  267.     long        XMM_Ret;
  268.  
  269.     printq("Try Moves from Wrap Area\n");
  270.     MoveS.Length = BUFLEN*2;
  271.     MoveS.SourceHandle = 0;
  272.     MoveS.SourceOffset = 0xFFFFF800L;
  273.     XMM_Ret = XMM_MoveExtended(&MoveS);
  274.     if ( XMM_Ret < 0 )
  275.         Error("Move Extended at end of Conventional", XMM_Ret);
  276.  
  277.     MoveS.Length += 2;
  278.     XMM_Ret = XMM_MoveExtended(&MoveS);
  279.     if ( XMSERROR(XMM_Ret) != (char)0xA7 )
  280.         Error("Move Extended overflowing end of Conventional", XMM_Ret);
  281. }
  282.  
  283. void EnableA20(void)
  284. {
  285.     long    XMM_Ret;
  286.  
  287.     printq("Enable A20: ");
  288.     XMM_Ret = XMM_EnableA20();
  289.     if ( XMM_Ret < 0 )
  290.         Error("A20 not enabled", XMM_Ret);
  291.     QueryA20();
  292. }
  293.  
  294. void DisableA20(void)
  295. {
  296.     long    XMM_Ret;
  297.  
  298.     printq("Disable A20: ");
  299.     XMM_Ret = XMM_DisableA20();
  300.     if ( XMM_Ret < 0 )
  301.         Error("A20 not disabled", XMM_Ret);
  302.     QueryA20();
  303. }
  304.  
  305. void QueryA20(void)
  306. {
  307.     long    X